import CryptoJS from 'crypto-js/crypto-js'
// 默认的 KEY 与 iv 如果没有给
const KEY = CryptoJS.enc.Utf8.parse('1234567890123456')
const IV = CryptoJS.enc.Utf8.parse('1234567890123456')

const u = navigator.userAgent

/**
 * @description 地球半径
 */
const EARTH_RADIUS = 6378.137

/**
 * @description 规则协议
 */
const protocol = {
  checkMobile: function (val) {
    // 检查手机号码
    var rule = /^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\d{8}$/ // 2018新型手机号正则表达式
    return rule.test(val)
  },
  checkEmail: function (val) {
    // 检查email地址
    let email = val || ''
    return email.length > 3 && email.indexOf('@') > -1
  },
  checkCardNo: function (val) {
    // 检查身份证号码
    var reg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/ // 身份证号码为15位或者18位,15位时全为数字,18位前17位为数字,最后一位是校验位,可能为数字或字符X
    return reg.test(val)
  },
  checkChinese: function (val) {
    // 检查汉字
    var reg = /^[\u4e00-\u9fa5]+$/
    return reg.test(val)
  },
  checkNumber: function (val) {
    // 检查金额/面积等数值(可带小数点)
    var reg = /^(([1-9][0-9]*)|(([0]\.\d{1,2}|[1-9][0-9]*\.\d{1,2})))$/
    return reg.test(val)
  }
}

/**
 * @description 常用工具类
 */
const common = {
  /**
   * @description 校验检查[手机号码,email地址,身份证号码,汉字等](策略模式)
   */
  check: {
    protocolContent: {
      protocolContent(type, val) {
        return protocol[type](val)
      }
    }
  },

  /**
   * @description 判断客户端是否是iOS或者Android
   */
  isAndroid() {
    if (u.indexOf('Android') > -1 || u.indexOf('Adr') > -1) {
      // android终端
      return true
    } else if (!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/)) {
      // ios终端
      return false
    }
  },

  /**
   * @description 将url与参数键值对拼接为最终的url
   * @param {String} url url
   * @param {Object} params 键值对参数对象
   */
  urlByAppendingParams(url, params) {
    let result = url
    if (result.substr(result.length - 1) !== '?') {
      result = result + `?`
    }

    for (let key in params) {
      let value = params[key]
      result += `${encodeURIComponent(key)}=${encodeURIComponent(value)}&`
    }

    result = result.substring(0, result.length - 1)
    return result
  },

  /**
   * @description 超过显示的最大长度部分则以...继续显示
   * @param {String} val 文本
   * @param {Number} showLength 需要显示最大的长度
   */
  lengthLimit(val, showLength) {
    if (val === 'undefined') {
      return ''
    } else {
      if (val.length > showLength) {
        return val.substring(0, showLength) + '...'
      } else {
        return val
      }
    }
  },

  /**
   * @description badge图标上的数字大于`limit`,则显示`limit`+
   * @param {Number} number 消息个数
   * @param {Number} limit 限制的个数
   */
  badgeFormat(number, limit) {
    if (number > limit) {
      return limit + '+'
    }
    return number
  },

  /**
   * @description 隐藏手机号
   * @param {Number} mobile 手机号
   */
  hideMobile(mobile) {
    if (mobile.length > 7) {
      var newMobile = mobile.substr(0, 3) + '****' + mobile.substr(7)
    }
    return newMobile
  },

  /**
   * @description 隐藏邮箱
   * @param {String} email
   */
  hideEmail(email) {
    if (String(email).indexOf('@') > 0) {
      var str = email.split('@')
      var _s = ''
      if (str[0].length > 3) {
        for (var i = 0; i < str[0].length - 3; i++) {
          _s += '*'
        }
      }
      var newEmail = str[0].substr(0, 3) + _s + '@' + str[1]
    }
    return newEmail
  },

  /**
   * @description 通过Js对电话和姓名身份证等进行部分隐藏处理
   * @param {String} str 字符串
   * @param {Number} frontLen 前面保留位数
   * @param {Number} endLen 后面保留位数
   */
  plusXing(str, frontLen, endLen) {
    var len = str.length - frontLen - endLen
    var xing = ''
    for (var i = 0; i < len; i++) {
      xing += '*'
    }
    return (
      str.substring(0, frontLen) + xing + str.substring(str.length - endLen)
    )
  },

  /**
   * @description 版本比较 VersionCompare
   * @param {String} currVer 当前版本.
   * @param {String} promoteVer 比较版本.
   * @return {Boolean} false 当前版本小于比较版本返回 true.
   * VersionCompare("6.3","5.2.5"); // false.
   * VersionCompare("6.1", "6.1"); // false.
   * VersionCompare("6.1.5", "6.2"); // true.
   */
  versionCompare(currVer, promoteVer) {
    currVer = currVer || '0.0.0'
    promoteVer = promoteVer || '0.0.0'
    if (currVer === promoteVer) return false
    var currVerArr = currVer.split('.')
    var promoteVerArr = promoteVer.split('.')
    var len = Math.max(currVerArr.length, promoteVerArr.length)
    for (var i = 0; i < len; i++) {
      var proVal = ~~promoteVerArr[i]
      var curVal = ~~currVerArr[i]
      if (proVal < curVal) {
        return false
      } else if (proVal > curVal) {
        return true
      }
    }
    return false
  },

  /**
   * @description 去掉字符串前后所有空格
   * @param {String} str
   */
  trim(str) {
    return str.replace(/(^\s*)|(\s*$)/g, '')
  },

  /**
   * @description 自定义时间
   * @param {String} item 时间戳
   */
  customTime(item) {
    // now
    let nowTime = new Date().getTime()
    let minuteTime = 60 * 1000
    let hourTime = 60 * minuteTime
    let dayTime = 24 * hourTime
    let monthTime = dayTime * 30
    let yearTime = monthTime * 12
    // history
    let publish = new Date(item)
    let publishTime = publish.getTime()
    let date = publish.getDate()
    let year = publish.getFullYear()
    let month =
      publish.getMonth() < 9 ?
      `0${publish.getMonth() + 1}` :
      publish.getMonth() + 1
    let historyTime = parseInt(nowTime) - parseInt(publishTime)
    let descTime
    if (historyTime >= yearTime) {
      // 按年算
      descTime = `${year}-${month}-${date}`
    } else if (historyTime < yearTime && historyTime >= monthTime) {
      // 按月算
      descTime = `${month}-${date}`
    } else if (historyTime < monthTime && historyTime >= dayTime) {
      // 按天算
      descTime = parseInt(historyTime / dayTime) + '天前'
    } else if (historyTime < dayTime && historyTime >= hourTime) {
      // 按小时算
      descTime = parseInt(historyTime / hourTime) + '小时前'
    } else if (historyTime < hourTime && historyTime >= minuteTime) {
      // 按分钟算
      descTime = parseInt(historyTime / minuteTime) + '分钟前'
    } else {
      descTime = '刚刚'
    }
    return descTime
  },

  /**
   * @description 时间显示格式过滤器
   * @param {String} val 时间戳
   */
  timeFilter(val) {
    function getDateDiff(dateTimeStamp) {
      const diffValue = new Date().getTime() - dateTimeStamp
      if (diffValue < 0) {
        return ''
      }
      const minute = 1000 * 60
      const hour = minute * 60
      const day = hour * 24
      const month = day * 30
      const monthC = diffValue / month
      const weekC = diffValue / (7 * day)
      const dayC = diffValue / day
      const hourC = diffValue / hour
      const minC = diffValue / minute
      let result = ''
      if (monthC >= 1) {
        result = parseInt(monthC) + '个月前'
      } else if (weekC >= 1) {
        result = parseInt(weekC) + '周前'
      } else if (dayC >= 1) {
        result = parseInt(dayC) + '天前'
      } else if (hourC >= 1) {
        result = parseInt(hourC) + '个小时前'
      } else if (minC >= 1) {
        result = parseInt(minC) + '分钟前'
      } else {
        result = '刚刚'
      }
      return result
    }
    return getDateDiff(val)
  },

  /**
   * @description
   * 对Date的扩展，将 Date 转化为指定格式的String
   * 月(M)、日(d)、小时(h)、分(m)、秒(s)、季度(q) 可以用 1-2 个占位符
   * 年(y)可以用 1-4 个占位符，毫秒(S)只能用 1 个占位符(是 1-3 位的数字)
   * (new Date()).Format("yyyy-MM-dd hh:mm:ss.S") ==> 2006-07-02 08:09:04.423
   * (new Date()).Format("yyyy-M-d h:m:s.S")      ==> 2006-7-2 8:9:4.18
   * @param {Date} date 日期
   * @param {String} fmt 日期格式化
   */
  dateFormat(date, fmt) {
    var o = {
      'M+': date.getMonth() + 1, // 月份
      'd+': date.getDate(), // 日
      'h+': date.getHours(), // 小时
      'm+': date.getMinutes(), // 分
      's+': date.getSeconds(), // 秒
      'q+': Math.floor((date.getMonth() + 3) / 3), // 季度
      S: date.getMilliseconds() // 毫秒
    }
    if (/(y+)/.test(fmt)) {
      fmt = fmt.replace(
        RegExp.$1,
        (date.getFullYear() + '').substr(4 - RegExp.$1.length)
      )
    }
    for (var k in o) {
      if (new RegExp('(' + k + ')').test(fmt)) {
        fmt = fmt.replace(
          RegExp.$1,
          RegExp.$1.length === 1 ?
          o[k] :
          ('00' + o[k]).substr(('' + o[k]).length)
        )
      }
    }
    return fmt
  },

  /**
   * @description 时间戳格式化
   * @param {String} timestamp 时间戳
   */
  timestampFormat(timestamp) {
    function zeroize(num) {
      return (String(num).length === 1 ? '0' : '') + num
    }

    var curTimestamp = parseInt(new Date().getTime() / 1000) // 当前时间戳
    var timestampDiff = curTimestamp - timestamp // 参数时间戳与当前时间戳相差秒数

    var curDate = new Date(curTimestamp * 1000) // 当前时间日期对象
    var tmDate = new Date(timestamp * 1000) // 参数时间戳转换成的日期对象

    var Y = tmDate.getFullYear()
    var m = tmDate.getMonth() + 1
    var d = tmDate.getDate()
    var H = tmDate.getHours()
    var i = tmDate.getMinutes()
    // var s = tmDate.getSeconds()
    if (timestampDiff < 60) {
      // 一分钟以内
      return this.$t('common.just')
    } else if (timestampDiff < 3600) {
      // 一小时前之内
      return Math.floor(timestampDiff / 60) + this.$t('common.min')
    } else if (
      curDate.getFullYear() === Y &&
      curDate.getMonth() + 1 === m &&
      curDate.getDate() === d
    ) {
      return this.$t('common.today') + zeroize(H) + ':' + zeroize(i)
    } else {
      var newDate = new Date((curTimestamp - 86400) * 1000) // 参数中的时间戳加一天转换成的日期对象
      if (
        newDate.getFullYear() === Y &&
        newDate.getMonth() + 1 === m &&
        newDate.getDate() === d
      ) {
        return this.$t('common.yesterday') + zeroize(H) + ':' + zeroize(i)
      } else if (curDate.getFullYear() === Y) {
        return (
          zeroize(m) + '-' + zeroize(d) + ' ' + zeroize(H) + ':' + zeroize(i)
        )
      } else {
        return (
          Y +
          '-' +
          zeroize(m) +
          '-' +
          zeroize(d) +
          ' ' +
          zeroize(H) +
          ':' +
          zeroize(i)
        )
      }
    }
  },

  /**
   * @description 判断数组是否为空
   * @param {String} value 数组
   */
  arrayIsEmpty(value) {
    return (
      (Array.isArray(value) && value.length === 0) ||
      (Object.prototype.isPrototypeOf(value) && Object.keys(value).length === 0)
    )
  },

  /**
   * @description 通过value删除数组元素
   * @param {Array} arr 数组
   * @param {String} value value
   */
  removeByValue(arr, value) {
    let i = arr.length
    while (i--) {
      if (arr[i] === value) {
        arr.splice(i, 1)
      }
    }
  },

  /**
   * @description 判断value是否存在数组
   * @param {Array} arr 数组
   * @param {String} value value
   */
  isInArray(arr, value) {
    let i = arr.length
    while (i--) {
      if (arr[i] === value) {
        return true
      }
    }
  },

  /**
   * @description 判断字符是否为空
   * @param {String} obj 字符
   */
  charisEmpty(obj) {
    if (typeof obj === 'undefined' || obj === null || obj === '') {
      return true
    } else {
      return false
    }
  },

  /**
   * @description 过滤JS数组中的空值,返回新的数组
   * @param {Array} array 需要过滤的数组
   */
  clearArrTrim(array) {
    for (var i = 0; i < array.length; i++) {
      if (array[i] === '' || typeof array[i] === 'undefined') {
        array.splice(i, 1)
        i = i - 1
      }
    }
    return array
  },

  /**
   * @description 过滤JS数组中的空值,假值等(es6语法)
   * @param {Array} array 需要过滤的数组
   */
  filter_array(array) {
    return array.filter(item => item)
  },

  /**
   * @description 生成全局唯一标识符UUID
   */
  uuid() {
    var s = []
    var hexDigits = '0123456789abcdef'
    for (var i = 0; i < 36; i++) {
      s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1)
    }
    s[14] = '4' // bits 12-15 of the time_hi_and_version field to 0010
    s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1) // bits 6-7 of the clock_seq_hi_and_reserved to 01
    // s[8] = s[13] = s[18] = s[23] = "-"; // ios/android端mid有‘-’识别不出来,暂时需要将‘-’隐藏起来
    s[8] = s[13] = s[18] = s[23] = ''

    var uuid = s.join('')
    return uuid
  },

  /**
   * @description 将用角度表示的角转换为近似相等的用弧度表示的角 java Math.toRadians
   * @param {Number} d rad
   */
  rad(d) {
    return (d * Math.PI) / 180.0
  },

  /**
   * @description 谷歌地图计算两个坐标点的距离(单位:km)[注意:如果定位失败的话,传入的是两个空值,并且返回0,给予处理]
   * @param {String} lng1  经度1
   * @param {String} lat1  纬度1
   * @param {String} lng2  经度2
   * @param {String} lat2  纬度2
   */
  getDistance(lng1, lat1, lng2, lat2) {
    if (lng1 === '' && lat1 === '') {
      return 0 // 如果定位失败的话,传入的是两个空值,并且返回0,给予处理
    }
    if ((lng2 === null || lng2 === '') && (lat2 === null || lat2 === '')) {
      return 0 // 如果定位失败的话,传入的是两个空值,并且返回0,给予处理
    }
    var radLat1 = this.rad(lat1)
    var radLat2 = this.rad(lat2)
    var a = radLat1 - radLat2
    var b = this.rad(lng1) - this.rad(lng2)
    var s =
      2 *
      Math.asin(
        Math.sqrt(
          Math.pow(Math.sin(a / 2), 2) +
          Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)
        )
      )
    s = s * EARTH_RADIUS
    // s = Math.round(s * 10000) / 10000; // 精确到小数点后四位
    s = (Math.round(s * 10000) / 10000).toFixed(2) // 保留两位小数
    return s
  },

  /**
   * @description 数字千位符格式化
   * @param {String} num 数字
   * @param {Number} precision 小数点位数
   * @param {String} separator 分割符号
   *=======================================================
   *     formatNumber(10000)="10,000"
   *     formatNumber(10000, 2)="10,000.00"
   *     formatNumber(10000.123456, 2)="10,000.12"
   *     formatNumber(10000.123456, 2, ' ')="10 000.12"
   *     formatNumber(.123456, 2, ' ')="0.12"
   *     formatNumber(56., 2, ' ')="56.00"
   *     formatNumber(56., 0, ' ')="56"
   *     formatNumber('56.')="56"
   *     formatNumber('56.a')=NaN
   *=======================================================
   */
  formatNumber(num, precision, separator) {
    var parts
    // 判断是否为数字
    if (!isNaN(parseFloat(num)) && isFinite(num)) {
      // 把类似.5,5.之类的数据转化成0.5,5,为数据精度处理做准,至于为什么
      // 不在判断中直接写if(!isNaN(num = parseFloat(num)) && isFinite(num))
      // 是因为parseFloat有一个奇怪的精度问题,比如 parseFloat(12312312.1234567119)
      // 的值变成了12312312.123456713
      num = Number(num)
      // 处理小数点位数
      num = (typeof precision !== 'undefined' ?
        num.toFixed(precision) :
        num
      ).toString()
      // 分离数字的小数部分和整数部分
      parts = num.split('.')
      // 整数部分加[separator]分隔,借用一个著名的正则表达式
      parts[0] = parts[0]
        .toString()
        .replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1' + (separator || ','))
      return parts.join('.')
    }
    // return NaN;
    return ''
  },

  /**
   * @description 小数点后面不足n位数补0
   * @param {Number} value 数值
   * @param {Number} num 补零位数
   */
  formatNumberZeroize(value, num) {
    var a, b, c, i
    a = value.toString()
    b = a.indexOf('.')
    c = a.length
    if (num === 0) {
      if (b !== -1) {
        a = a.substring(0, b)
      }
    } else {
      // 如果没有小数点
      if (b === -1) {
        a = a + '.'
        for (i = 1; i <= num; i++) {
          a = a + '0'
        }
      } else {
        // 有小数点,超出位数自动截取,否则补0
        a = a.substring(0, b + num + 1)
        for (i = c; i <= b + num; i++) {
          a = a + '0'
        }
      }
    }
    return a
  },

  /**
   * @description 格式化资金方向[0 来账 1 往账]
   * @param {Number} num 0 来账 1 往账
   */
  directionFormat(num) {
    let str
    switch (num) {
      case 0:
        str = '<span style="color:#fcb816">+</span>'
        break
      case 1:
        str = '<span style="color:#000000">-</span>'
        break
      default:
        str = ''
        break
    }
    return str
  },

  /**
   * @description 格式化成Html字符串
   */
  formatStringWithHtml(originString) {
    if (originString === undefined) {
      return ''
    }
    const newString = originString
      .replace(/&nbsp;/g, ' ')
      .replace(/&quot;/g, '"')
      .replace(/&amp;/g, '&')
      .replace(/&lt;/g, '<')
      .replace(/&gt;/g, '>')
    return newString
  },

  /**
   * 过滤字符串中的html标签
   * @param {Html} str
   */
  removeHtmlTag(str) {
    return str.replace(/<[^>]+>/g, '') // 去掉所有的html标记
  },

  /**
   * @description JS数据容量单位转换(b,kb,mb,gb,tb,pb,eb,zb,yb)
   * @param {String} bytes 字节
   * @see http://www.cnblogs.com/jialinG/p/9577724.html
   * 使用方式:var size = '8164674';console.log(bytesToSize(parseInt(size)));
   */
  bytesToSize(bytes) {
    if (bytes === 0) return '0 B'
    var k = 1000 // or 1024
    var sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
    var i = Math.floor(Math.log(bytes) / Math.log(k))
    return (bytes / Math.pow(k, i)).toPrecision(3) + ' ' + sizes[i]
  },

  /**
   * @description 函数调用n秒后才会执行,如果函数在n秒内被调用的话则函数不执行,重新计算执行时间
   * @param {Method} method 需要去抖的函数体
   * @param {Number} delay 在多少秒内该函数只能触发一次.默认2秒内.防止多次触发
   *
   * usage:
   *
   * old:
   *
   * actionMethods (params) {
   *   alert('abc)
   * }
   *
   * new:
   * actionMethods: this.$utils.debounce((params) => {
   *   alert('abc')
   * },500)
   *
   *
   */
  debounce(method, delay = 300) {
    let timer = null
    return function () {
      const context = this
      const args = arguments
      clearTimeout(timer)
      timer = setTimeout(function () {
        method.apply(context, args)
      }, delay)
    }
  },

  /**
   * @description 函数节流,防止函数在特定时间内多次执行
   * @param {Method} method 需要节流的函数体
   * @param {Number} duration 在多少秒内该函数只能触发一次.默认1.5秒内.防止多次触发
   *
   * usage:
   *
   * old:
   *
   * actionMethods (params) {
   *   alert('abc)
   * }
   *
   * new:
   * actionMethods: this.$utils.throttle((params) => {
   *   alert('abc')
   * },2500)
   *
   */
  throttle(method, duration = 1500) {
    let begin = new Date()
    return function () {
      const context = this
      const args = arguments
      const current = new Date()
      if (current - begin >= duration) {
        method.apply(context, args)
        begin = current
      }
    }
  },

  /**
   * @description 相加
   * @param {Number} arg1 被加数
   * @param {Number} arg2 加数
   */
  accAdd(arg1, arg2) {
    var r1, r2, m
    try {
      r1 = arg1.toString().split('.')[1].length
    } catch (e) {
      r1 = 0
    }
    try {
      r2 = arg2.toString().split('.')[1].length
    } catch (e) {
      r2 = 0
    }
    m = Math.pow(10, Math.max(r1, r2))
    return (arg1 * m + arg2 * m) / m
  },

  /**
   * @description 相乘
   * @param {Number} arg1 被乘数
   * @param {Number} arg2 乘数
   */
  accMultiply(arg1, arg2) {
    var m = 0
    var s1 = arg1.toString()
    var s2 = arg2.toString()
    try {
      m += s1.split('.')[1].length
    } catch (e) {}
    try {
      m += s2.split('.')[1].length
    } catch (e) {}
    return (
      (Number(s1.replace('.', '')) * Number(s2.replace('.', ''))) /
      Math.pow(10, m)
    )
  },

  /**
   * @description 比较两个日期的大小
   * @param {String} arg1 日期1
   * @param {String} arg2 日期2
   */
  CompareDate(d1, d2) {
    return ((new Date(d1.replace(/-/g, '\\/'))) > (new Date(d2.replace(/-/g, '\\/'))))
  },

  /**
   * AES加密 ：字符串 key iv  返回base64
   */
  Encrypt(word, keyStr, ivStr) {
    let key = KEY
    let iv = IV
    if (keyStr) {
      key = CryptoJS.enc.Utf8.parse(keyStr)
      iv = CryptoJS.enc.Utf8.parse(ivStr)
    }
    let srcs = CryptoJS.enc.Utf8.parse(word)
    var encrypted = CryptoJS.AES.encrypt(srcs, key, {
      iv: iv,
      mode: CryptoJS.mode.CBC,
      padding: CryptoJS.pad.ZeroPadding
    })
    return CryptoJS.enc.Base64.stringify(encrypted.ciphertext)
  },

  /**
   * AES 解密 ：字符串 key iv  返回base64
   */
  Decrypt(word, keyStr, ivStr) {
    let key = KEY
    let iv = IV
    if (keyStr) {
      key = CryptoJS.enc.Utf8.parse(keyStr)
      iv = CryptoJS.enc.Utf8.parse(ivStr)
    }
    let base64 = CryptoJS.enc.Base64.parse(word)
    let src = CryptoJS.enc.Base64.stringify(base64)
    var decrypt = CryptoJS.AES.decrypt(src, key, {
      iv: iv,
      mode: CryptoJS.mode.CBC,
      padding: CryptoJS.pad.ZeroPadding
    })
    var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8)
    return decryptedStr.toString()
  },

  /**
   * 检查手机号码
   */
  checkMobile(val) {
    // 检查手机号码
    var rule = /^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\d{8}$/; // 电话正则表达式
    return rule.test(val);
  },

  /**
   * 验证密码6-16位数字和字母组合
   */
  checkPassword(val) {
    var rule = /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,16}$/;
    return rule.test(val);
  },

  /**
   * 检查邮箱号码
   */
  checkEmail(val) {
    // 检查email地址
    let email = val || '';
    return email.length > 3 && email.indexOf('@') > -1;
  },

  /**
   * @description 格式化犯规的个数样式
   * @param {Number} num 个数
   */
  foulFormat(num) {
    let str = ''
    for (var i = 0; i < num; i++) {
      str += '• '
    }
    if (num == 0) {
      return `<span></span>`
    } else if (num > 0 && num <= 4) {
      return `<span style="color: #ffff00; font-weight: 700;">${str}</span>`
    } else if (num >= 5) {
      return `<span style="color: #ff0000; font-weight: 700;">${str}</span>`
    }
    return str
  }
}

export default common
